﻿//
// Copyright 2024 Exhunter Technology Co.Ltd2.
//

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace X18.Framework.Core.Utils
{
    /// <summary>
    /// 字符串函数
    /// </summary>
    public static class StringUtils
    {
        /// <summary>
        /// 判断指定的字符串是否是空引用，或空字符串
        /// </summary>
        /// <param name="value">要判断的字符串</param>
        /// <returns>如果字符串是NULL引用或者是Empty, 则为true; 否则为false</returns>
        public static bool IsEmpty(this string value)
        {
            return value == null || value.Trim().Length <= 0;
        }

        /// <summary>
        /// 判断指定的字符串是否相等(忽略大小写)
        /// </summary>
        /// <param name="str1">要比较的第一个字符串</param>
        /// <param name="str2"> 要比较的第二个字符串</param>
        /// <returns>如果认为对象相等，则为 true；否则为 false。</returns>
        public static bool EqualsIgnoreCase(this string str1, string str2)
        {
            return string.Equals(str1, str2, StringComparison.OrdinalIgnoreCase);
        }

        /// <summary>
        /// 判断指定的字符串是否是由数字及26个英文字母组成
        /// </summary>
        /// <param name="value">要判断的字符串</param>
        /// <returns>如果字符串是由数字及26个英文字母组成, 则为true; 否则为false</returns>
        public static bool IsNumberAndLetters(this string value)
        {
            return value != null && value.Trim().Length > 0 && Regex.IsMatch(value, "^[A-Za-z0-9]+$");
        }

        /// <summary>
        ///  判断指定的字符串是否是无符号数值
        /// </summary>
        /// <param name="value">要判断的字符串</param>
        /// <returns>如果是无符号数值， 则为true； 否则为false</returns>
        public static bool IsUnsign(this string value)
        {
            if (value.Length == 0)
            {
                return false;
            }

            return Regex.IsMatch(value, "^\\d*[.]?\\d*$");
        }

        /// <summary>
        /// 判断指定的字符串是否是整数
        /// </summary>
        /// <param name="value">要判断的字符串</param>
        /// <returns>如果是整数， 则为true； 否则为false</returns>
        public static bool IsInt(this string value)
        {
            if (value.Length == 0)
            {
                return false;
            }

            return Regex.IsMatch(value, "^[+-]?\\d*$");
        }

        /// <summary>
        /// 判断指定的字符串是否是数值
        /// </summary>
        /// <param name="value">要判断的字符串</param>
        /// <returns>如果是数值， 则为true； 否则为false</returns>
        public static bool IsNumeric(this string value)
        {
            if (value.Length == 0)
            {
                return false;
            }

            return Regex.IsMatch(value, "^[+-]?\\d*[.]?\\d*$");
        }

        /// <summary>
        /// 判断指定的字符串是否是日期
        /// </summary>
        /// <param name="value">要判断的字符串</param>
        /// <returns>如果是日期， 则为true； 否则为false</returns>
        public static bool IsDate(this string value)
        {
            DateTime _;
            return DateTime.TryParse(value, out _);
        }

        /// <summary>
        /// 在指定的正则表达式模式所定义的位置，拆分指定的输入字符串。
        /// </summary>
        /// <param name="value">要拆分的字符串</param>
        /// <param name="pattern">要匹配的正则表达式</param>
        /// <returns字符串数组></returns>
        public static string[] SplitRegex(this string value, string pattern)
        {
            Regex regex = new Regex(pattern);
            return regex.Split(value);
        }

        /// <summary>
        /// 在指定的正则表达式模式所定义的位置，将指定的输入字符串拆分指定的最大次数。
        /// </summary>
        /// <param name="value">要拆分的字符串</param>
        /// <param name="pattern">要匹配的正则表达式</param>
        /// <param name="limit">可拆分的最大次数</param>
        /// <returns>字符串数组</returns>
        public static string[] SplitRegex(this string value, string pattern, int limit)
        {
            Regex regex = new Regex(pattern);
            return regex.Split(value, limit);
        }

        /// <summary>
        /// 根据分隔符拆分字符串，并转换为整型集合
        /// </summary>
        /// <param name="value">要拆分的字符串</param>
        /// <param name="split">分割符</param>
        /// <returns></returns>
        public static List<int> ToIntList(this string value, char split)
        {
            List<int> result = new List<int>();
            if (!string.IsNullOrEmpty(value))
            {
                string[] buffer = value.Split(new char[1]
                {
                    split
                }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string s in buffer)
                {
                    int rst;
                    if (int.TryParse(s, out rst))
                    {
                        result.Add(rst);
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 根据分隔符拆分字符串，并转换为整型集合
        /// </summary>
        /// <param name="value">要拆分的字符串</param>
        /// <param name="split">分割符</param>
        /// <returns></returns>
        public static List<long> ToLongList(this string value, char split)
        {
            List<long> result = new List<long>();
            if (!string.IsNullOrEmpty(value))
            {
                string[] buffer = value.Split(new char[1]
                {
                    split
                }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string s in buffer)
                {
                    long rst;
                    if (long.TryParse(s, out rst))
                    {
                        result.Add(rst);
                    }
                }
            }
            return result;
        }
    }
}